package com.atguigu.lambda;

import java.util.*;
import java.util.function.*;
import java.util.stream.Collectors;

/**
 * 函数式接口：只要是函数式接口就可以用Lambda表达式简化
 * 函数式接口：接口中只有一个未实现的方法，这个接口就叫函数式接口
 */
@FunctionalInterface    //检查注解，检查该接口是否是函数式接口
interface MyInterface {
    int sum(int a, int b);

    default int test02() {
        return 2;
    }

    ; //默认实现
}

@FunctionalInterface
interface MyInterface2 {
    void test();
}

//1、自己写实现类
class MyInterfaceImpl implements MyInterface, MyInterface2 {
    @Override
    public void test() {
        System.out.println("test方法调用");
    }

    @Override
    public int sum(int a, int b) {
        return a + b;
    }
}




public class Lambda {

    public static void main(String[] args) {
        BiConsumer<String, String> biConsumer = (a, b) -> System.out.println(a + "Test BiConsumer" + b);
        biConsumer.accept("1", "2");
    }

    public static void test01(String[] args) {
        //1、创建实现类对象
        MyInterface myInterface = new MyInterfaceImpl();
        System.out.println(myInterface.sum(1, 2));

        //2、创建匿名实现类
        MyInterface myInterface1 = new MyInterface() {
            @Override
            public int sum(int a, int b) {
                return a * a + b * b;
            }
        };
        System.out.println(myInterface1.sum(2, 3));
        //以上均为冗余写法

        //3、lambda表达式（完整写法）   参数列表 + 箭头 + 方法体
        MyInterface myInterface2 = (int a, int b) -> {
            return a * a + b * b;
        };
        System.out.println(myInterface2.sum(2, 3));

        //4、lambda简化写法
        //参数类型可以不写，只写变量名、参数变量名随意，参数可以为空
        //方法体如果只有一句话，也可以省略不写
        MyInterface myInterface3 = (a, b) -> a * a + b * b;
        System.out.println(myInterface3.sum(2, 3));
        System.out.println("======");
        MyInterface2 myInterface4 = () -> {
            System.out.println("test01");
        };
        myInterface4.test();

        var names = new ArrayList<String>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        //比较器原生写法
        System.out.println("====比较器原生写法====");
        Collections.sort(names, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }
        });
        System.out.println(names);

        System.out.println("====比较器简化写法====");
        //函数式接口
        Collections.sort(names, (o1, o2) ->  o1.compareTo(o2));
        //类::方法，引用类中的实例方法
        Collections.sort(names, String::compareTo); //仅适用正序
        System.out.println(names);

        new Thread(() -> System.out.println("testThread")).start();
    }
}
